Artigos Java Tratamento de Exceções em Java: Desmistificando a Certificação SCJP6 Parte IX - Parte 1

Capturando uma Exception com try e catch

Fique preparado para diversas perguntas no exame que incluam o controle de fluxo como parte do seu código, até mesmo aquelas que não estiverem ali analisando especificamente seu conhecimento sobre o assunto.

A especificação de Java estabelece que “uma exceção será lançada quando restrições semânticas forem violadas”, o que implica que exceção é lançada em situações que são não possíveis ou em violações sérias do comportamento admissível do sistema.

Então, precisamos de um modo de informar a JVM que código efetuar quando determinada exceção acontecer. Para fazer isso, usam-se as palavras-chave try e catch. 


        package br.com.devmedia;



        import java.io.BufferedReader;

        import java.io.FileReader;

        import java.io.IOException;



        public class ExceptionTratamento {



        /**

        * @param args

        */

        public static void main(String[] args) {

        try{

        BufferedReader buffer = new BufferedReader(new FileReader("teste.txt"));

        }catch (IOException e) {

        System.out.println("Arquivo não encontrado "+ "teste.txt");

        }



        }



        }

Um dos grandes benefícios da utilização da manipulação de exceções é que o código de manipulação de alguma exceção específica, que possa acontecer na região controlada, precisa ser escrito apenas uma única vez. 


        Bloco (finally)

O bloco finally vai definir o código que sempre será executado em algum local, após do bloco try, se uma exceção for ou não lançada.

Mesmo se acontecer uma instrução return no bloco try, o bloco finally será executado depois dessa instrução. Esse é o ponto ideal para fechar os arquivos, executar qualquer outra rotina de limpeza que seu código necessitar ou liberar os soquetes de rede.

Iremos avaliar o exemplo abaixo.


        package br.com.devmedia;

        public class X {

        static X x1;

        static X x2;

        static int divisao(int a, int b){

        return a/b;

        }

        /**

        * @param args

        */

        public static void main(String[] args) {

        try{

        System.out.println("Try sendo executado.");

        x1 = new X();

        x2 = new X();

        dividir(7,0);

        System.out.println("Esse ponto nunca será "+ "execultado");

        }catch (ArithmeticException e) {

        System.out.println("Catch sendo executado.");

        }finally{

        System.out.println("Finally sendo executado!");

        }

        }

        }

Saída:
Try sendo executado.
Catch sendo executado.
Finally sendo executado!

O bloco finally não é obrigatório. Além disso, já que o compilador não determina nem mesmo cláusulas catch, em algumas situações você poderá se encontrar com um bloco try seguido imediatamente por um finally.

Veja o exemplo a seguir, de um try sem um catch, mas com um finally. A exceção é lançada, mas mesmo assim o bloco finally é efetuado. 


        package br.com.devmedia;

        public class Y {

        static Y a1;

        static Y a2;

        static int dividir(int a, int b){

        return a/b;

        }

        /**

        * @param args

        */

        public static void main(String[] args) {

        try{

        System.out.println("Try em execução.");

        a1 = new Y();

        a2 = new Y();

        dividir(4,0);

        System.out.println("Esse local não será executado");

        }finally{

        System.out.println("Finally sendo executado!");

        }

        }

        }

Saída:
Try em execucução.
Exception in thread "main" Finally sendo executado!
t1 está sujeito ao coletor de lixo
t2 está sujeito ao coletor de lixo
java.lang.ArithmeticException: / by zero
at br.com.devmedia.Y.dividir(Y.java:10)
at br.com.devmedia.Y.main(Y.java:21)

Não é considerado correto utilizar uma cláusula try sem um catch ou finally. Um try individual causa erro de compilação. Qualquer cláusula catch deve vir imediatamente após o try. Qualquer finally precisa vir imediatamente após a última cláusula catch, ou deve seguir logo após o try, na inexistência de catch.

Na continuação desse artigo trataremos um pouco mais de Exception, suas definições e sua API.

Leia todos artigos da série